/*
 * Copyright 2010-2012 Susanta Tewari. <freecode4susant@users.sourceforge.net>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package bd.org.apache.commons.math.linear;

import bd.org.apache.commons.math.analysis.UnivariateFunction;
import bd.org.apache.commons.math.exception.DimensionMismatchException;
import bd.org.apache.commons.math.exception.MathArithmeticException;
import bd.org.apache.commons.math.exception.NullArgumentException;
import bd.org.apache.commons.math.exception.NumberIsTooLargeException;
import bd.org.apache.commons.math.exception.util.LocalizedFormats;
import bd.org.apache.commons.math.util.FastMath;
import bd.org.apache.commons.math.util.MathUtils;

import java.io.Serializable;
import java.util.Arrays;
import java.util.Iterator;

/**
 * This class implements the {@link RealVector} interface with a double array.
 *
 * @version $Id: ArrayRealVector.java 1296539 2012-03-03 00:47:39Z sebb $
 * @since 2.0
 */
public class ArrayRealVector extends RealVector implements Serializable {

    /**
     * Serializable version identifier.
     */
    private static final long serialVersionUID = -1097961340710804027L;

    /**
     * Default format.
     */
    private static final RealVectorFormat DEFAULT_FORMAT = RealVectorFormat.getInstance();

    /**
     * Entries of the vector.
     */
    private double data[];

    /**
     * Build a 0-length vector.
     * Zero-length vectors may be used to initialized construction of vectors
     * by data gathering. We start with zero-length and use either the {@link
     * #ArrayRealVector(ArrayRealVector, ArrayRealVector)} constructor
     * or one of the {@code append} method ({@link #append(double)},
     * {@link #append(ArrayRealVector)}) to gather data into this vector.
     */
    public ArrayRealVector() {

        data = new double[0];
    }

    /**
     * Construct a vector from another vector, using a deep copy.
     *
     * @param v Vector to copy.
     */
    public ArrayRealVector(ArrayRealVector v) {

        this(v, true);
    }

    /**
     * Construct a vector from an array, copying the input array.
     *
     * @param d Array.
     */
    public ArrayRealVector(double[] d) {

        data = d.clone();
    }

    /**
     * Construct a vector from an array.
     *
     * @param d Array of {@code Double}s.
     */
    public ArrayRealVector(Double[] d) {

        data = new double[d.length];

        for (int i = 0; i < d.length; i++) {

            data[i] = d[i].doubleValue();
        }
    }

    /**
     * Construct a vector of zeroes.
     *
     * @param size Size of the vector.
     */
    public ArrayRealVector(int size) {

        data = new double[size];
    }

    /**
     * Construct a vector from another vector, using a deep copy.
     *
     * @param v vector to copy.
     */
    public ArrayRealVector(RealVector v) {

        if (v == null) {
            throw new NullArgumentException();
        }

        data = new double[v.getDimension()];

        for (int i = 0; i < data.length; ++i) {

            data[i] = v.getEntry(i);
        }
    }

    /**
     * Construct a vector by appending one vector to another vector.
     *
     * @param v1 First vector (will be put in front of the new vector).
     * @param v2 Second vector (will be put at back of the new vector).
     */
    public ArrayRealVector(ArrayRealVector v1, ArrayRealVector v2) {

        data = new double[v1.data.length + v2.data.length];

        System.arraycopy(v1.data, 0, data, 0, v1.data.length);
        System.arraycopy(v2.data, 0, data, v1.data.length, v2.data.length);
    }

    /**
     * Construct a vector from another vector.
     *
     * @param v Vector to copy.
     * @param deep If {@code true} perform a deep copy, otherwise perform a
     * shallow copy.
     */
    public ArrayRealVector(ArrayRealVector v, boolean deep) {

        data = deep
               ? v.data.clone()
               : v.data;
    }

    /**
     * Construct a vector by appending one vector to another vector.
     *
     * @param v1 First vector (will be put in front of the new vector).
     * @param v2 Second vector (will be put at back of the new vector).
     */
    public ArrayRealVector(ArrayRealVector v1, double[] v2) {

        final int l1 = v1.getDimension();
        final int l2 = v2.length;

        data = new double[l1 + l2];

        System.arraycopy(v1.data, 0, data, 0, l1);
        System.arraycopy(v2, 0, data, l1, l2);
    }

    /**
     * Construct a vector by appending one vector to another vector.
     *
     * @param v1 First vector (will be put in front of the new vector).
     * @param v2 Second vector (will be put at back of the new vector).
     */
    public ArrayRealVector(ArrayRealVector v1, RealVector v2) {

        final int l1 = v1.data.length;
        final int l2 = v2.getDimension();

        data = new double[l1 + l2];

        System.arraycopy(v1.data, 0, data, 0, l1);

        for (int i = 0; i < l2; ++i) {

            data[l1 + i] = v2.getEntry(i);
        }
    }

    /**
     * Construct a vector by appending one vector to another vector.
     *
     * @param v1 First vector (will be put in front of the new vector).
     * @param v2 Second vector (will be put at back of the new vector).
     */
    public ArrayRealVector(double[] v1, ArrayRealVector v2) {

        final int l1 = v1.length;
        final int l2 = v2.getDimension();

        data = new double[l1 + l2];

        System.arraycopy(v1, 0, data, 0, l1);
        System.arraycopy(v2.data, 0, data, l1, l2);
    }

    /**
     * Create a new ArrayRealVector using the input array as the underlying
     * data array.
     * If an array is built specially in order to be embedded in a
     * ArrayRealVector and not used directly, the {@code copyArray} may be
     * set to {@code false}. This will prevent the copying and improve
     * performance as no new array will be built and no data will be copied.
     *
     * @param d Data for the new vector.
     * @param copyArray if {@code true}, the input array will be copied,
     * otherwise it will be referenced.
     * @see #ArrayRealVector(double[])
     */
    public ArrayRealVector(double[] d, boolean copyArray) {

        if (d == null) {
            throw new NullArgumentException();
        }

        data = copyArray
               ? d.clone()
               : d;
    }

    /**
     * Construct a vector by appending one vector to another vector.
     *
     * @param v1 first vector (will be put in front of the new vector)
     * @param v2 second vector (will be put at back of the new vector)
     */
    public ArrayRealVector(double[] v1, double[] v2) {

        final int l1 = v1.length;
        final int l2 = v2.length;

        data = new double[l1 + l2];

        System.arraycopy(v1, 0, data, 0, l1);
        System.arraycopy(v2, 0, data, l1, l2);
    }

    /**
     * Construct a vector with preset values.
     *
     * @param size Size of the vector
     * @param preset All entries will be set with this value.
     */
    public ArrayRealVector(int size, double preset) {

        data = new double[size];

        Arrays.fill(data, preset);
    }

    /**
     * Construct a vector by appending one vector to another vector.
     *
     * @param v1 First vector (will be put in front of the new vector).
     * @param v2 Second vector (will be put at back of the new vector).
     */
    public ArrayRealVector(RealVector v1, ArrayRealVector v2) {

        final int l1 = v1.getDimension();
        final int l2 = v2.data.length;

        data = new double[l1 + l2];

        for (int i = 0; i < l1; ++i) {

            data[i] = v1.getEntry(i);
        }

        System.arraycopy(v2.data, 0, data, l1, l2);
    }

    /**
     * Construct a vector from part of a array.
     *
     * @param d Array.
     * @param pos Position of first entry.
     * @param size Number of entries to copy.
     * than {@code pos + size}.
     */
    public ArrayRealVector(double[] d, int pos, int size) {

        if (d == null) {
            throw new NullArgumentException();
        }

        if (d.length < pos + size) {
            throw new NumberIsTooLargeException(pos + size, d.length, true);
        }

        data = new double[size];

        System.arraycopy(d, pos, data, 0, size);
    }

    /**
     * Construct a vector from part of an array.
     *
     * @param d Array.
     * @param pos Position of first entry.
     * @param size Number of entries to copy.
     * than {@code pos + size}.
     */
    public ArrayRealVector(Double[] d, int pos, int size) {

        if (d == null) {
            throw new NullArgumentException();
        }

        if (d.length < pos + size) {
            throw new NumberIsTooLargeException(pos + size, d.length, true);
        }

        data = new double[size];

        for (int i = pos; i < pos + size; i++) {

            data[i - pos] = d[i].doubleValue();
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public ArrayRealVector copy() {

        return new ArrayRealVector(this, true);
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public ArrayRealVector add(RealVector v) {

        if (v instanceof ArrayRealVector) {

            final double[] vData = ((ArrayRealVector) v).data;
            final int      dim   = vData.length;

            checkVectorDimensions(dim);

            ArrayRealVector result     = new ArrayRealVector(dim);
            double[]        resultData = result.data;

            for (int i = 0; i < dim; i++) {

                resultData[i] = data[i] + vData[i];
            }

            return result;

        } else {

            checkVectorDimensions(v);

            double[]        out = data.clone();
            Iterator<Entry> it  = v.sparseIterator();
            Entry           e;

            while (it.hasNext() && (e = it.next()) != null) {

                out[e.getIndex()] += e.getValue();
            }

            return new ArrayRealVector(out, false);
        }
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public ArrayRealVector subtract(RealVector v) {

        if (v instanceof ArrayRealVector) {

            final double[] vData = ((ArrayRealVector) v).data;
            final int      dim   = vData.length;

            checkVectorDimensions(dim);

            ArrayRealVector result     = new ArrayRealVector(dim);
            double[]        resultData = result.data;

            for (int i = 0; i < dim; i++) {

                resultData[i] = data[i] - vData[i];
            }

            return result;

        } else {

            checkVectorDimensions(v);

            double[]        out = data.clone();
            Iterator<Entry> it  = v.sparseIterator();
            Entry           e;

            while (it.hasNext() && (e = it.next()) != null) {

                out[e.getIndex()] -= e.getValue();
            }

            return new ArrayRealVector(out, false);
        }
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public ArrayRealVector map(UnivariateFunction function) {

        return copy().mapToSelf(function);
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public ArrayRealVector mapToSelf(UnivariateFunction function) {

        for (int i = 0; i < data.length; i++) {

            data[i] = function.value(data[i]);
        }

        return this;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public RealVector mapAddToSelf(double d) {

        for (int i = 0; i < data.length; i++) {

            data[i] = data[i] + d;
        }

        return this;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public RealVector mapSubtractToSelf(double d) {

        for (int i = 0; i < data.length; i++) {

            data[i] = data[i] - d;
        }

        return this;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public RealVector mapMultiplyToSelf(double d) {

        for (int i = 0; i < data.length; i++) {

            data[i] = data[i] * d;
        }

        return this;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public RealVector mapDivideToSelf(double d) {

        for (int i = 0; i < data.length; i++) {

            data[i] = data[i] / d;
        }

        return this;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public ArrayRealVector ebeMultiply(RealVector v) {

        if (v instanceof ArrayRealVector) {

            final double[] vData = ((ArrayRealVector) v).data;
            final int      dim   = vData.length;

            checkVectorDimensions(dim);

            ArrayRealVector result     = new ArrayRealVector(dim);
            double[]        resultData = result.data;

            for (int i = 0; i < dim; i++) {

                resultData[i] = data[i] * vData[i];
            }

            return result;

        } else {

            checkVectorDimensions(v);

            double[] out = data.clone();

            for (int i = 0; i < data.length; i++) {

                out[i] *= v.getEntry(i);
            }

            return new ArrayRealVector(out, false);
        }
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public ArrayRealVector ebeDivide(RealVector v) {

        if (v instanceof ArrayRealVector) {

            final double[] vData = ((ArrayRealVector) v).data;
            final int      dim   = vData.length;

            checkVectorDimensions(dim);

            ArrayRealVector result     = new ArrayRealVector(dim);
            double[]        resultData = result.data;

            for (int i = 0; i < dim; i++) {

                resultData[i] = data[i] / vData[i];
            }

            return result;

        } else {

            checkVectorDimensions(v);

            double[] out = data.clone();

            for (int i = 0; i < data.length; i++) {

                out[i] /= v.getEntry(i);
            }

            return new ArrayRealVector(out, false);
        }
    }


    /**
     * Get a reference to the underlying data array.
     * This method does not make a fresh copy of the underlying data.
     *
     * @return the array of entries.
     */
    public double[] getDataRef() {

        return data;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double dotProduct(RealVector v) {

        if (v instanceof ArrayRealVector) {

            final double[] vData = ((ArrayRealVector) v).data;

            checkVectorDimensions(vData.length);

            double dot = 0;

            for (int i = 0; i < data.length; i++) {

                dot += data[i] * vData[i];
            }

            return dot;

        } else {

            checkVectorDimensions(v);

            double          dot = 0;
            Iterator<Entry> it  = v.sparseIterator();
            Entry           e;

            while (it.hasNext() && (e = it.next()) != null) {

                dot += data[e.getIndex()] * e.getValue();
            }

            return dot;
        }
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double getNorm() {

        double sum = 0;

        for (double a : data) {

            sum += a * a;
        }

        return FastMath.sqrt(sum);
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double getL1Norm() {

        double sum = 0;

        for (double a : data) {

            sum += FastMath.abs(a);
        }

        return sum;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double getLInfNorm() {

        double max = 0;

        for (double a : data) {

            max = FastMath.max(max, FastMath.abs(a));
        }

        return max;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double getDistance(RealVector v) {

        if (v instanceof ArrayRealVector) {

            final double[] vData = ((ArrayRealVector) v).data;

            checkVectorDimensions(vData.length);

            double sum = 0;

            for (int i = 0; i < data.length; ++i) {

                final double delta = data[i] - vData[i];

                sum += delta * delta;
            }

            return FastMath.sqrt(sum);

        } else {

            checkVectorDimensions(v);

            double sum = 0;

            for (int i = 0; i < data.length; ++i) {

                final double delta = data[i] - v.getEntry(i);

                sum += delta * delta;
            }

            return FastMath.sqrt(sum);
        }
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double getL1Distance(RealVector v) {

        if (v instanceof ArrayRealVector) {

            final double[] vData = ((ArrayRealVector) v).data;

            checkVectorDimensions(vData.length);

            double sum = 0;

            for (int i = 0; i < data.length; ++i) {

                final double delta = data[i] - vData[i];

                sum += FastMath.abs(delta);
            }

            return sum;

        } else {

            checkVectorDimensions(v);

            double sum = 0;

            for (int i = 0; i < data.length; ++i) {

                final double delta = data[i] - v.getEntry(i);

                sum += FastMath.abs(delta);
            }

            return sum;
        }
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double getLInfDistance(RealVector v) {

        if (v instanceof ArrayRealVector) {

            final double[] vData = ((ArrayRealVector) v).data;

            checkVectorDimensions(vData.length);

            double max = 0;

            for (int i = 0; i < data.length; ++i) {

                final double delta = data[i] - vData[i];

                max = FastMath.max(max, FastMath.abs(delta));
            }

            return max;

        } else {

            checkVectorDimensions(v);

            double max = 0;

            for (int i = 0; i < data.length; ++i) {

                final double delta = data[i] - v.getEntry(i);

                max = FastMath.max(max, FastMath.abs(delta));
            }

            return max;
        }
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public RealVector unitVector() {

        final double norm = getNorm();

        if (norm == 0) {
            throw new MathArithmeticException(LocalizedFormats.ZERO_NORM);
        }

        return mapDivide(norm);
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public void unitize() {

        final double norm = getNorm();

        if (norm == 0) {
            throw new MathArithmeticException(LocalizedFormats.ZERO_NORM);
        }

        mapDivideToSelf(norm);
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public RealVector projection(RealVector v) {

        return v.mapMultiply(dotProduct(v) / v.dotProduct(v));
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public RealMatrix outerProduct(RealVector v) {

        if (v instanceof ArrayRealVector) {

            final double[]   vData = ((ArrayRealVector) v).data;
            final int        m     = data.length;
            final int        n     = vData.length;
            final RealMatrix out   = MatrixUtils.createRealMatrix(m, n);

            for (int i = 0; i < m; i++) {

                for (int j = 0; j < n; j++) {

                    out.setEntry(i, j, data[i] * vData[j]);
                }
            }

            return out;

        } else {

            final int        m   = data.length;
            final int        n   = v.getDimension();
            final RealMatrix out = MatrixUtils.createRealMatrix(m, n);

            for (int i = 0; i < m; i++) {

                for (int j = 0; j < n; j++) {

                    out.setEntry(i, j, data[i] * v.getEntry(j));
                }
            }

            return out;
        }
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double getEntry(int index) {

        return data[index];
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public int getDimension() {

        return data.length;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public RealVector append(RealVector v) {

        try {
            return new ArrayRealVector(this, (ArrayRealVector) v);
        } catch (ClassCastException cce) {
            return new ArrayRealVector(this, v);
        }
    }


    /**
     * Construct a vector by appending a vector to this vector.
     *
     * @param v Vector to append to this one.
     * @return a new vector.
     */
    public ArrayRealVector append(ArrayRealVector v) {

        return new ArrayRealVector(this, v);
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public RealVector append(double in) {

        final double[] out = new double[data.length + 1];

        System.arraycopy(data, 0, out, 0, data.length);

        out[data.length] = in;

        return new ArrayRealVector(out, false);
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public RealVector getSubVector(int index, int n) {

        ArrayRealVector out = new ArrayRealVector(n);

        try {
            System.arraycopy(data, index, out.data, 0, n);
        } catch (IndexOutOfBoundsException e) {

            checkIndex(index);
            checkIndex(index + n - 1);
        }

        return out;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public void setEntry(int index, double value) {

        try {
            data[index] = value;
        } catch (IndexOutOfBoundsException e) {
            checkIndex(index);
        }
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public void addToEntry(int index, double increment) {

        data[index] += increment;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public void setSubVector(int index, RealVector v) {

        if (v instanceof ArrayRealVector) {
            setSubVector(index, ((ArrayRealVector) v).data);
        } else {

            try {

                for (int i = index; i < index + v.getDimension(); ++i) {

                    data[i] = v.getEntry(i - index);
                }

            } catch (IndexOutOfBoundsException e) {

                checkIndex(index);
                checkIndex(index + v.getDimension() - 1);
            }
        }
    }


    /**
     * Set a set of consecutive elements.
     *
     * @param index Index of first element to be set.
     * @param v Vector containing the values to set.
     */
    public void setSubVector(int index, double[] v) {

        try {
            System.arraycopy(v, 0, data, index, v.length);
        } catch (IndexOutOfBoundsException e) {

            checkIndex(index);
            checkIndex(index + v.length - 1);
        }
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public void set(double value) {

        Arrays.fill(data, value);
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public double[] toArray() {

        return data.clone();
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public String toString() {

        return DEFAULT_FORMAT.format(this);
    }


    /**
     * Check if instance and specified vectors have the same dimension.
     *
     * @param v Vector to compare instance with.
     */
    @Override
    protected void checkVectorDimensions(RealVector v) {

        checkVectorDimensions(v.getDimension());
    }


    /**
     * Check if instance dimension is equal to some expected value.
     *
     * @param n Expected dimension.
     */
    @Override
    protected void checkVectorDimensions(int n) {

        if (data.length != n) {
            throw new DimensionMismatchException(data.length, n);
        }
    }


    /**
     * Check if any coordinate of this vector is {@code NaN}.
     *
     * @return {@code true} if any coordinate of this vector is {@code NaN},
     *         {@code false} otherwise.
     */
    @Override
    public boolean isNaN() {

        for (double v : data) {

            if (Double.isNaN(v)) {
                return true;
            }
        }

        return false;
    }


    /**
     * Check whether any coordinate of this vector is infinite and none
     * are {@code NaN}.
     *
     * @return {@code true} if any coordinate of this vector is infinite and
     *         none are {@code NaN}, {@code false} otherwise.
     */
    @Override
    public boolean isInfinite() {

        if (isNaN()) {
            return false;
        }

        for (double v : data) {

            if (Double.isInfinite(v)) {
                return true;
            }
        }

        return false;
    }


    /**
     * Test for the equality of two real vectors.
     * If all coordinates of two real vectors are exactly the same, and none are
     * {@code NaN}, the two real vectors are considered to be equal.
     * {@code NaN} coordinates are considered to affect globally the vector
     * and be equals to each other - i.e, if either (or all) coordinates of the
     * real vector are equal to {@code NaN}, the real vector is equal to
     * a vector with all {@code NaN} coordinates.
     *
     * @param other Object to test for equality.
     * @return {@code true} if two vector objects are equal, {@code false} if
     *         {@code other} is null, not an instance of {@code RealVector}, or
     *         not equal to this {@code RealVector} instance.
     */
    @Override
    public boolean equals(Object other) {

        if (this == other) {
            return true;
        }

        if ((other == null) ||!(other instanceof RealVector)) {
            return false;
        }

        RealVector rhs = (RealVector) other;

        if (data.length != rhs.getDimension()) {
            return false;
        }

        if (rhs.isNaN()) {
            return this.isNaN();
        }

        for (int i = 0; i < data.length; ++i) {

            if (data[i] != rhs.getEntry(i)) {
                return false;
            }
        }

        return true;
    }


    /**
     * Get a hashCode for the real vector.
     * All {@code NaN} values have the same hash code.
     *
     * @return a hash code.
     */
    @Override
    public int hashCode() {

        if (isNaN()) {
            return 9;
        }

        return MathUtils.hash(data);
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public ArrayRealVector combine(double a, double b, RealVector y) {

        return copy().combineToSelf(a, b, y);
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public ArrayRealVector combineToSelf(double a, double b, RealVector y) {

        if (y instanceof ArrayRealVector) {

            final double[] yData = ((ArrayRealVector) y).data;

            checkVectorDimensions(yData.length);

            for (int i = 0; i < this.data.length; i++) {

                data[i] = a * data[i] + b * yData[i];
            }

        } else {

            checkVectorDimensions(y);

            for (int i = 0; i < this.data.length; i++) {

                data[i] = a * data[i] + b * y.getEntry(i);
            }
        }

        return this;
    }
}
